﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using ClienteWinMGI.Logica;
using ComunesMGI.DataTypes;
using System.Collections;
using ComunesMGI.Constantes;
using ComunesMGI.Mensajes;
using ComunesMGI.Condiciones;
using ComunesMGI.Enums;

namespace ClienteWinMGI.Presentacion
{
    public partial class GestionControl : UserControl
    {
        //ATRIBUTOS USADOS EN COMUN POR DIFERENTES TABS
        private List<DataCliente> _clientes;


        //ATRIBUTO USADO PARA EL TAB DE WORK WITH
        private List<DataWP> _workPackages;
        private List<DataSistema> _sistemasWP;

        //ATRIBUTOS USADOS PARA EL TAB DE TAREAS
        private List<DataSistema> _sistemasTareas;
        private List<DataIncidente> _incidentesTareas;

        private List<DataTarea> _tareas;

        //ATRIBUTOS USADOS PARA EL TAB DE CLIENTES Y SOLUCIONES
        private List<DataSistema> _sistemasSoluciones;

        //ATRIBUTOS USADOS PARA EL TAB DE INCIDENTES
        private List<DataSistema> _sistemasIncidentes;
        private List<DataIncidente> _incidentes;

        public GestionControl()
        {
            InitializeComponent();
            try
            {
                CargarClientesInicial();
                ActualizarTablaClientes();
                EstilizarComponentes();
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "Error al cargar los clientes", ex.Message);
                err.ShowDialog();
            }
        }

       

        private void EstilizarComponentes()
        {
            this.grillaSistemas.BackgroundColor = this.BackColor;
            this.grillaSistemas.GridColor = this.BackColor;
            this.grillaClientes.BackgroundColor = this.BackColor;
            this.grillaClientes.GridColor = this.BackColor;
            this.grillaTareas.BackgroundColor = this.BackColor;
            this.grillaTareas.GridColor = this.BackColor;
            this.dataGridViewIncidentes.BackgroundColor = this.BackColor;
            this.dataGridViewIncidentes.GridColor = this.BackColor;
            this.dataGridWP.BackgroundColor = this.BackColor;
            this.dataGridWP.GridColor = this.BackColor;
        }

    

        #region CosasGenerales
        public List<DataWP> WorkPackages
        {
            set { _workPackages = value; }
            get { return _workPackages; }
        }
        private void CargarClientesInicial()
        {
            IClientes iClientes = LogicaFactory.getInstance().getIClientes();
            _clientes = iClientes.GetClientes();
            cboCliente.SelectedIndex = -1;
            cboClienteTarea.SelectedIndex = -1;
            cboClienteSol.SelectedIndex = -1;
            comboBoxCliente.SelectedIndex = -1;
            cboCliente.Items.Clear();
            cboClienteTarea.Items.Clear();
            cboClienteSol.Items.Clear();
            comboBoxCliente.Items.Clear();
            foreach (DataCliente dc in _clientes)
            {
                cboCliente.Items.Add(dc.Nombre);
                cboClienteTarea.Items.Add(dc.Nombre);
                cboClienteSol.Items.Add(dc.Nombre);
                comboBoxCliente.Items.Add(dc.Nombre);
            }
            cboCliente.SelectedIndex = -1;
            cboClienteTarea.SelectedIndex = -1;
            cboClienteSol.SelectedIndex = -1;
            comboBoxCliente.SelectedIndex = -1;
        
        }

        public void CargarClientes()
        {

            try
            {
               
                CargarClientesInicial();
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "Error al cargar los clientes", ex.Message);
                err.ShowDialog();
            }

        }
        public void VolverAEstadoInicialGeneral()
        {
            CargarClientes();
            ActualizarTablaClientes();
            VolverAEstadoInicialTareas();
            VolverAEstadoInicialWP();
            VolverAEstadoInicialSistemas();
            VolverAEstadoInicialIncidentes();
    
        }

        public void VolverAEstadoAntesSistema()
        {
            cboCliente.SelectedIndex = -1;
            cboClienteTarea.SelectedIndex = -1;
            comboBoxCliente.SelectedIndex = -1;
            VolverAEstadoInicialTareas();
            VolverAEstadoInicialWP();
            VolverAEstadoInicialIncidentes();
        }

        #endregion
     



        #region Incidentes

        private void buttonAgregar_Click(object sender, EventArgs e)
        {
            AltaIncidente _altaIncidente = new AltaIncidente();
            _altaIncidente.ShowDialog();
            ActualizarGrillaIncidentes();
        }
        private void buttonEliminarIncidente_Click(object sender, EventArgs e)
        {
            try
            {
                if (dataGridViewIncidentes.DataSource != null)
                {
                    int posInc = obtenerIndiceIncidenteSeleccionado();
                    if (posInc >= 0)
                    {
                        //existe un incidente seleccionado
                        //obtengo el incidente seleccionado
                        DataIncidente dataInc = _incidentes.ElementAt(posInc);
                        IIncidentes inc = LogicaFactory.getInstance().getIIncidentes();
                        DataSistema actualDs = _sistemasIncidentes.First(ds => ds.Nombre == comboBoxSolucion.SelectedItem.ToString());
                        inc.EliminarIncidente(actualDs.Codigo, dataInc.IdIncidente);
                        //inc.BajaIncidene(dataInc.IdIncidente);
                        MsgNotificacion notif = new MsgNotificacion("Baja Incidente", "Eliminación Exitosa", "Se ha dado de baja el incidente con id=" + dataInc.IdIncidente);
                        notif.ShowDialog();
                        //VolverAEstadoInicialGeneral();
                        ActualizarGrillaIncidentes();


                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningun incidente", "Debe seleccionar el incidente a eliminar");
                        err.ShowDialog();
                    }

                }
                else
                {
                    MsgError err = new MsgError("Error", "No se seleccionó ningun incidente", "Debe seleccionar el incidente a eliminar");
                    err.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }

        private void comboBoxSolucion_SelectedIndexChanged(object sender, EventArgs e)
        {
            DataSistema actualDs = _sistemasIncidentes.First(ds => ds.Nombre == comboBoxSolucion.SelectedItem.ToString());
            IIncidentes ii = LogicaFactory.getInstance().getIIncidentes();
            List<string> estados=ii.GetEstadosIncidentes(actualDs.Codigo);
            comboBoxEstado.Items.Clear();
            foreach (string est in estados)
            {
                comboBoxEstado.Items.Add(est);
            }
            comboBoxEstado.SelectedIndex = -1;
            comboBoxEstado.Enabled = true;
            
            

        }

        private void buttonVisualizar_Click(object sender, EventArgs e)
        {
            try
            {
                if (dataGridViewIncidentes.DataSource != null)
                {
                    if (dataGridViewIncidentes.SelectedRows.Count > 0)
                    {
                        DataSistema actualDs = _sistemasIncidentes.First(ds => ds.Nombre == comboBoxSolucion.SelectedItem.ToString());
                        DataIncidente di = _incidentes.ElementAt(dataGridViewIncidentes.SelectedRows[0].Index);
                        AltaIncidente modif = new AltaIncidente(di.IdIncidente, actualDs.Codigo, true);
                        modif.ShowDialog();
                        buttonActualizar_Click(null, null);
                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningun incidente", "Debe seleccionar el incidente a visualizar");
                        err.ShowDialog();
                    }

                }
                else
                {
                    MsgError err = new MsgError("Error", "No se seleccionó ningun incidente", "Debe seleccionar el incidente a visualizar");
                    err.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }

        }

        private int obtenerIndiceIncidenteSeleccionado()
        {
            DataGridViewSelectedRowCollection col = dataGridViewIncidentes.SelectedRows;
            bool salir = false;
            int i = 0;
            while (!salir && i < dataGridViewIncidentes.RowCount)
            {
                DataGridViewRow fila = dataGridViewIncidentes.Rows[i];
                if (col.Contains(fila))
                {
                    salir = true;

                }
                else
                {
                    i++;
                }
            }
            if (salir)
                return i;
            else
                return -1;
        }

        private void ActualizarGrillaIncidentes()
        {
            try
            {
                if (comboBoxCliente.SelectedIndex != -1 && comboBoxSolucion.SelectedIndex != -1)
                {
                    //OBTENGO EL SISTEMA SELECCIONADO
                    DataSistema actualDs = _sistemasIncidentes.First(ds => ds.Nombre == comboBoxSolucion.SelectedItem.ToString());
                    IIncidentes ii = LogicaFactory.getInstance().getIIncidentes();

                    //obtengo la lista de tareas
                    _incidentes = ii.GetIncidentes(actualDs.Codigo, null);

                    DataTable datosTabla = new DataTable("tablaIncidentes");
                    datosTabla.Columns.Add("Identificador", typeof(string));
                    datosTabla.Columns.Add("Descripcion", typeof(string));

                    foreach (DataIncidente di in _incidentes)
                    {
                        DataRow dataR = datosTabla.NewRow();
                        dataR[0] = di.IdIncidente;
                        dataR[1] = di.Descripcion;
                        datosTabla.Rows.Add(dataR);
                    }

                    dataGridViewIncidentes.DataSource = datosTabla;

                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }

        private void buttonModificar_Click(object sender, EventArgs e)
        {

            try
            {
                if (dataGridViewIncidentes.DataSource != null)
                {
                    if (dataGridViewIncidentes.SelectedRows.Count > 0)
                    {
                        DataSistema actualDs = _sistemasIncidentes.First(ds => ds.Nombre == comboBoxSolucion.SelectedItem.ToString());
                        DataIncidente di = _incidentes.ElementAt(dataGridViewIncidentes.SelectedRows[0].Index);
                        AltaIncidente modif = new AltaIncidente(di.IdIncidente, actualDs.Codigo,false);
                        modif.ShowDialog();
                        buttonActualizar_Click(null, null);
                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningun incidente", "Debe seleccionar el incidente a modificar");
                        err.ShowDialog();
                    }

                }
                else
                {
                    MsgError err = new MsgError("Error", "No se seleccionó ningun incidente", "Debe seleccionar el incidente a modificar");
                    err.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }

        private void buttonActualizar_Click(object sender, EventArgs e)
        {
            try
            {
                //me fijo si tengo seleccionado un cliente y un sistema
                if (comboBoxCliente.SelectedIndex != -1 && comboBoxSolucion.SelectedIndex != -1)
                {
                    //OBTENGO EL SISTEMA SELECCIONADO
                    DataSistema actualDs = _sistemasIncidentes.First(ds => ds.Nombre == comboBoxSolucion.SelectedItem.ToString());
                    IIncidentes ii = LogicaFactory.getInstance().getIIncidentes();

                    //obtengo la lista de incidentes
                    List<Condicion> listaCondiciones = new List<Condicion>();
                    Condicion fechaDesde = new Condicion(OperadorLogico.MayorIgual,"Creado",false,dateTimePicker1.Value.ToString(ConstantesMGI.FormatoFechas), CampoSharepoint.DateTime);
                    Condicion fechaHasta = new Condicion(OperadorLogico.MenorIgual, "Creado", false, dateTimePicker2.Value.ToString(ConstantesMGI.FormatoFechas), CampoSharepoint.DateTime); 
                    listaCondiciones.Add(fechaDesde);
                    listaCondiciones.Add(fechaHasta);

                    if (comboBoxEstado.SelectedIndex > 0)
                    {
                        Condicion estado = new Condicion(OperadorLogico.Igual, "Estado", false, comboBoxEstado.SelectedItem.ToString(), CampoSharepoint.Choice);
                        listaCondiciones.Add(estado);
                    }
                    
                    _incidentes = ii.GetIncidentes(actualDs.Codigo,listaCondiciones);

                    DataTable datosTabla = new DataTable("tablaIncidentes");
                    datosTabla.Columns.Add("Identificador", typeof(string));
                    datosTabla.Columns.Add("Descripcion", typeof(string));

                    foreach (DataIncidente  di in _incidentes)
                    {
                        DataRow dataR = datosTabla.NewRow();
                        dataR[0] = di.IdIncidente;
                        dataR[1] = di.Descripcion;
                        datosTabla.Rows.Add(dataR);
                    }

                    dataGridViewIncidentes.DataSource = datosTabla;

                }
                else
                {
                    MsgNotificacion n = new MsgNotificacion("Faltan datos", "Ingrese cliente y sistema", "debe seleccionar el cliente y el sistema");
                    n.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }

        private void VolverAEstadoInicialIncidentes()
        {
            comboBoxSolucion.SelectedIndex = -1;
            comboBoxSolucion.Items.Clear();
            comboBoxSolucion.Enabled = false;
            comboBoxEstado.SelectedIndex = -1;
            comboBoxEstado.Items.Clear();
            comboBoxEstado.Enabled = false;
            dataGridViewIncidentes.DataSource = null;
            _incidentesTareas = null;
            _sistemasIncidentes = null;
            _incidentes  = null;

        }

        private void comboBoxCliente_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                if (comboBoxCliente.SelectedIndex != -1)
                {
                    //vacio el combo de los sistemas
                    
                 
                    comboBoxSolucion.Items.Clear();
                   
                    comboBoxSolucion.SelectedIndex = -1;
                    //pido los sistemas
                    LogicaFactory fabrica = LogicaFactory.getInstance();
                    ISistemas sist = fabrica.getISistemas();


                    //obtengo los datos del cliente seleccionado
                    DataCliente actualDc = _clientes.First(dc => dc.Nombre == comboBoxCliente.SelectedItem.ToString());

                    //pido los sistemas y los cargo en el combo
                    _sistemasIncidentes = sist.GetSistemas(actualDc.Codigo);
                    foreach (DataSistema ds in _sistemasIncidentes)
                    {
                        string item = ds.Nombre;
                        comboBoxSolucion.Items.Add(item);
                    }
                   
                    comboBoxSolucion.Enabled = true;
                    comboBoxSolucion.SelectedIndex = -1;

                    //vacio la grilla
                    dataGridViewIncidentes.DataSource = null;
                }
                else
                {
                    comboBoxSolucion.Items.Clear();
                    comboBoxSolucion.SelectedIndex = -1;
                    dataGridViewIncidentes.DataSource = null;
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }
        #endregion



        

     

        #region WorkPackages

        private void cboSolucion_SelectedIndexChanged(object sender, EventArgs e)
        {
            //vacio la grilla
            dataGridWP.DataSource = null;
        }

        private void btnActualizar_Click(object sender, EventArgs e)
        {

            try
            {
                //me fijo si tengo seleccionado un cliente y un sistema
                if (cboCliente.SelectedIndex != -1 && cboSistema.SelectedIndex != -1)
                {
                    //OBTENGO EL SISTEMA SELECCIONADO
                    DataSistema actualDs = _sistemasWP.First(ds => ds.Nombre == cboSistema.SelectedItem.ToString());

                    DataTable datosTabla = obtenerDatosTabla(actualDs.Codigo);
                    dataGridWP.DataSource = datosTabla;

                }
                else
                {
                    MsgNotificacion n = new MsgNotificacion("Faltan datos", "Ingrese cliente y sistema", "debe seleccionar el cliente y el sistema");
                    n.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }
        private DataTable obtenerDatosTabla(int idSis)
        {

            IIncidentes ii = LogicaFactory.getInstance().getIIncidentes();

            List<DataWP> listaWp = ii.GetWorkPackages(idSis);
            _workPackages = listaWp;
            //creo el datatable para cargarselo despues como datasource de la grilla
            DataTable datosTabla = new DataTable("tablaWP");
            datosTabla.Columns.Add("Nombre", typeof(string));
            datosTabla.Columns.Add("Estado", typeof(string));
            string nombreWP;
            string estadoWP;


            foreach (DataWP dp in listaWp)
            {
                nombreWP = dp.Nombre;
                estadoWP = dp.Estado.Estado;
                DataRow dataR = datosTabla.NewRow();
                dataR[0] = nombreWP;
                dataR[1] = estadoWP;
                datosTabla.Rows.Add(dataR);

            }

            return datosTabla;
        }

        private void btnEliminarWP_Click(object sender, EventArgs e)
        {
            try
            {
                if (cboSistema.SelectedIndex != -1)
                {
                    if (dataGridWP.DataSource == null)
                    {
                        MsgNotificacion n = new MsgNotificacion("Seleccione un work package", "Presione el boton de actualizar", " Presione el boton de actualizar para ver los Work Packages ");
                        n.ShowDialog();
                    }
                    else
                    {
                        int i = obtenerIndiceWPSeleccionado();
                        if (i >= 0)
                        {

                            DataWP datosWP = _workPackages.ElementAt(i);
                            LogicaFactory.getInstance().getIIncidentes().EliminarWorkPackage(datosWP.Id);
                            ActualizarGrillaWP();
                        }
                        else
                        {
                            MsgError er = new MsgError("Error", "Debe seleccionar un Work Package", "Seleccione un Work Package para eliminar");
                            er.ShowDialog();
                        }
                    }
                }
                else
                {
                    MsgError er = new MsgError("Error", "Debe seleccionar un sistema", "Seleccione un sistema y el boton de actualizar para poder ver los work packages y seleccionar uno");
                    er.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }

        }



        private void ActualizarGrillaWP()
        {
            if (cboCliente.SelectedIndex != -1 && cboSistema.SelectedIndex != -1)
            {
                //OBTENGO EL SISTEMA SELECCIONADO
                DataSistema actualDs = _sistemasWP.First(ds => ds.Nombre == cboSistema.SelectedItem.ToString());

                DataTable datosTabla = obtenerDatosTabla(actualDs.Codigo);
                dataGridWP.DataSource = datosTabla;

            }
            else
            {

                cboCliente.SelectedIndex = -1;
                cboSistema.SelectedIndex = -1;
                cboSistema.Items.Clear();
                cboSistema.Enabled = false;
                _workPackages = null;
                dataGridWP.DataSource = null;

            }

        }

        private void btnAgregar_Click(object sender, EventArgs e)
        {
            try
            {
                AltaWorkPackage altaWp = new AltaWorkPackage();
                altaWp.ShowDialog();
                ActualizarGrillaWP();
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }

        /// <summary>
        /// devuelve el indice en la lista de work packages del workpackage seleccionado, si es que se
        /// selecciono alguno, sino devuelve -1
        /// </summary>
        /// <returns>integer</returns>
        private int obtenerIndiceWPSeleccionado()
        {
            
            DataGridViewSelectedRowCollection col = dataGridWP.SelectedRows;
            bool salir = false;
            int i = 0;
            while (!salir && i < dataGridWP.RowCount)
            {
                DataGridViewRow fila = dataGridWP.Rows[i];
                if (col.Contains(fila))
                {
                    salir = true;

                }
                else
                {
                    i++;
                }
            }
            if (salir)
                return i;
            else
                return -1;
        }

        private void btnModificar_Click(object sender, EventArgs e)
        {
            try
            {
                if (cboSistema.SelectedIndex != -1)
                {
                    if (dataGridWP.DataSource == null)
                    {
                        MsgNotificacion n = new MsgNotificacion("Seleccione un work package", "Presione el boton de actualizar", " Presione el boton de actualizar para ver los Work Packages ");
                        n.ShowDialog();
                    }
                    else
                    {
                        int i = obtenerIndiceWPSeleccionado();
                        if (i >= 0)
                        {

                            DataWP datosWP = _workPackages.ElementAt(i);
                            ModificarWorkPackage modif = new ModificarWorkPackage(datosWP);
                            modif.ShowDialog();
                            ActualizarGrillaWP();
                        }
                        else
                        {
                            MsgError er = new MsgError("Error", "Debe seleccionar un Work Package", "Seleccione un Work Package para modificar");
                            er.ShowDialog();
                        }
                    }
                }
                else
                {
                    MsgError er = new MsgError("Error", "Debe seleccionar un sistema", "Seleccione un sistema y el boton de actualizar para poder ver los work packages y seleccionar uno");
                    er.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }
        private void btnVisualizar_Click(object sender, EventArgs e)
        {
            try
            {
                if (cboSistema.SelectedIndex != -1)
                {
                    if (dataGridWP.DataSource == null)
                    {
                        MsgNotificacion n = new MsgNotificacion("Seleccione un work package", "", "Debe seleccionar un Work Package");
                        n.ShowDialog();
                    }
                    else
                    {
                        int i = obtenerIndiceWPSeleccionado();
                        if (i >= 0)
                        {

                            DataWP datosWP = _workPackages.ElementAt(i);

                            DataSistema actualDs = _sistemasWP.First(ds => ds.Nombre == cboSistema.SelectedItem.ToString());
                            VisualizarWP visualizar = new VisualizarWP(datosWP, actualDs.Codigo);
                            visualizar.ShowDialog();
                        }
                        else
                        {
                            MsgError er = new MsgError("Error", "Debe seleccionar un Work Package", "Seleccione un Work Package para visualizar");
                            er.ShowDialog();
                        }
                    }
                }
                else
                {
                    MsgError er = new MsgError("Error", "Debe seleccionar un sistema", "Seleccione un sistema para poder ver la informacion de un Work Package");
                    er.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }

        }

        private void btnAsignarInc_Click(object sender, EventArgs e)
        {
            try
            {
                int i = obtenerIndiceWPSeleccionado();
                if (i >= 0)
                {

                    DataWP datosWP = _workPackages.ElementAt(i);
                    if (!datosWP.Estado.Final)
                    {
                        //en el caso de que el estado del work package no sea el estado final , permito agregar incidentes
                        DataSistema actualDs = _sistemasWP.First(ds => ds.Nombre == cboSistema.SelectedItem.ToString());
                        DataCliente actualDc = _clientes.First(dc => dc.Nombre == cboCliente.SelectedItem.ToString());
                        AsignarIncidentesWP asignacion = new AsignarIncidentesWP(actualDc.Codigo, actualDs.Codigo, datosWP);
                        asignacion.ShowDialog();
                    }
                    else 
                    {
                        MsgNotificacion notif = new MsgNotificacion("Asignacion no valida", "", "No se puede asignar incidentes al work package por que el estado del mismo es cerrado");
                        notif.ShowDialog();
                    }
                }
                else
                {
                    MsgError er = new MsgError("Error", "Debe seleccionar un dato", "Para poder asignar incidentes a un workPackage debe seleccionar un work package de la lista");
                    er.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError er = new MsgError("Error", "", ex.Message);
                er.ShowDialog();
            }

        }

        private void cboCliente_SelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                if (cboCliente.SelectedIndex != -1)
                {
                    //vacio el combo de los sistemas
                    cboSistema.Items.Clear();

                    //pido los sistemas
                    LogicaFactory fabrica = LogicaFactory.getInstance();
                    ISistemas sist = fabrica.getISistemas();

                    //obtengo los datos del cliente seleccionado
                    DataCliente actualDc = _clientes.First(dc => dc.Nombre == cboCliente.SelectedItem.ToString());

                    //pido los sistemas y los cargo en el combo
                    _sistemasWP = sist.GetSistemas(actualDc.Codigo);
                    foreach (DataSistema ds in _sistemasWP)
                    {
                        string item = ds.Nombre;
                        cboSistema.Items.Add(item);
                    }
                    cboSistema.SelectedIndex = -1;
                    cboSistema.Enabled = true;

                    //vacio la grilla
                    dataGridWP.DataSource = null;


                }
                else
                {
                    cboSistema.Items.Clear();
                    cboSistema.SelectedIndex = -1;
                    dataGridWP.DataSource = null;
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }

        }


        void VolverAEstadoInicialWP()
        {
            cboSistema.SelectedIndex = -1;
            cboSistema.Items.Clear();
            
            cboSistema.Enabled = false;
          
            _sistemasWP = null;
            _workPackages = null;
            dataGridWP.DataSource = null;
            this.Update();
        }



        private void button2_Click(object sender, EventArgs e)
        {
            try
            {
                int i = obtenerIndiceWPSeleccionado();
                if (i >= 0)
                {
                    DataWP datosWP = _workPackages.ElementAt(i);

                    List<DataIncidente> listaInc = LogicaFactory.getInstance().getIIncidentes().GetIncidentesWP(datosWP.IdSistema, datosWP.Id);
                    if (listaInc.Count != 0)
                    {



                        DesasociarIncidenteWP des = new DesasociarIncidenteWP(datosWP.Id, datosWP.IdSistema);
                        des.ShowDialog();
                    }
                    else
                    {
                        MsgNotificacion notif = new MsgNotificacion("Desasignacion", "", "El Work Package no tiene incidentes asignados");
                        notif.ShowDialog();
                    }
                }
                else
                {
                    MsgError er = new MsgError("Error", "Debe seleccionar un dato", "Para poder desasignar incidentes a un workPackage debe seleccionar un work package de la lista");
                    er.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError er = new MsgError("Error", "", ex.Message);
                er.ShowDialog();
            }

        }

        #endregion




        #region Tareas
        private void btnAgregarTarea_Click(object sender, EventArgs e)
        {
            AltaTarea _altaTarea = new AltaTarea();
            _altaTarea.ShowDialog();
            ActualizarGrillaTareas();
        }
        
        private void cboClienteTarea_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (cboClienteTarea.SelectedIndex != -1)
            {
                //vacio el combo de los sistemas 
                cboSistemaTarea.Items.Clear();
                try
                {
                    //pido los sistemas
                    LogicaFactory fabrica = LogicaFactory.getInstance();
                    ISistemas sist = fabrica.getISistemas();

                    //obtengo los datos del cliente seleccionado
                    DataCliente actualDc = _clientes.First(dc => dc.Nombre == cboClienteTarea.SelectedItem.ToString());


                    //pido los sistemas y los cargo en el combo
                    _sistemasTareas = sist.GetSistemas(actualDc.Codigo);
                    foreach (DataSistema ds in _sistemasTareas)
                    {

                        cboSistemaTarea.Items.Add(ds.Nombre);
                    }
                    cboSistemaTarea.SelectedIndex = -1;
                    cboSistemaTarea.Enabled = true;

                    //vacio la grilla de las tareas
                    grillaTareas.DataSource = null;

                }
                catch (Exception ex)
                {
                    MsgError err = new MsgError("Error", "Error al buscar los sistemas", ex.Message);
                    err.Show();
                }
            }

        }


        private int obtenerIndiceTareaSeleccionado()
        {
            DataGridViewSelectedRowCollection col = grillaTareas.SelectedRows;
            bool salir = false;
            int i = 0;
            while (!salir && i < grillaTareas.RowCount)
            {
                DataGridViewRow fila = grillaTareas.Rows[i];
                if (col.Contains(fila))
                {
                    salir = true;

                }
                else
                {
                    i++;
                }
            }
            if (salir)
                return i;
            else
                return -1;
        }



        private void cboSistemaTarea_SelectedIndexChanged(object sender, EventArgs e)
        {

            try
            {
                //vacio la grilla
                dataGridWP.DataSource = null;
                //lleno el combo de los incidentes
                if (cboSistemaTarea.SelectedIndex != -1)
                {
                    cboIncidenteTarea.SelectedIndex = -1;
                    cboIncidenteTarea.Items.Clear();


                    DataSistema actualDs = _sistemasTareas.First(ds => ds.Nombre == cboSistemaTarea.SelectedItem.ToString());
                    IIncidentes incidentes = LogicaFactory.getInstance().getIIncidentes();

                    //guardo la lista de incidentes
                    List<Condicion> condiciones = new List<Condicion>();
                    condiciones.Add(new Condicion(ComunesMGI.Enums.OperadorLogico.Distinto, "Estado", false, "Cerrado",CampoSharepoint.Choice));
                    _incidentesTareas = incidentes.GetIncidentes(actualDs.Codigo,condiciones);

                    //agrego los incidentes al combo
                    for (int i = 0; i < _incidentesTareas.Count(); i++)
                    {
                        string inc = "Id=" + _incidentesTareas[i].IdIncidente + ";" + "Desc=" + _incidentesTareas[i].Descripcion;
                        cboIncidenteTarea.Items.Add(inc);
                    }
                    cboIncidenteTarea.SelectedIndex = -1;
                    cboIncidenteTarea.Enabled = true;

                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }

        private void btnVisualizarTarea_Click(object sender, EventArgs e)
        {
            try
            {
                if (grillaTareas.DataSource != null)
                {
                    int posTarea = obtenerIndiceTareaSeleccionado();
                    if (posTarea >= 0)
                    {
                        DataSistema actualDs = _sistemasTareas.First(ds => ds.Nombre == cboSistemaTarea.SelectedItem.ToString());
                        DataTarea dataTarea = _tareas.ElementAt(posTarea);
                        AltaTarea visual = new AltaTarea(int.Parse(dataTarea.IdTarea), actualDs.Codigo, true);
                        visual.ShowDialog();
                        
                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ninguna tarea", "Debe seleccionar la tarea a visualizar");
                        err.ShowDialog();
                    }

                }
                else
                {
                    MsgError err = new MsgError("Error", "No se seleccionó ninguna tarea", "Debe seleccionar la tarea a visualizar");
                    err.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }

        }


         private void btnModificarTarea_Click_1(object sender, EventArgs e)
        
        {
            try
            {
                if (grillaTareas.DataSource != null)
                {
                    int posTarea = obtenerIndiceTareaSeleccionado();
                    if (posTarea >= 0)
                    {
                        DataSistema actualDs = _sistemasTareas.First(ds => ds.Nombre == cboSistemaTarea.SelectedItem.ToString());
                        DataTarea dataTarea = _tareas.ElementAt(posTarea);
                        AltaTarea modif = new AltaTarea(int.Parse(dataTarea.IdTarea),actualDs.Codigo,false);
                        modif.ShowDialog();
                        ActualizarGrillaTareas();
                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ninguna tarea", "Debe seleccionar la tarea a modificar");
                        err.ShowDialog();
                    }

                }
                else
                {
                    MsgError err = new MsgError("Error", "No se seleccionó ninguna tarea", "Debe seleccionar la tarea a modificar");
                    err.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }


        private void cboIncidenteTarea_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (cboIncidenteTarea.SelectedIndex != -1)
            {
                grillaTareas.DataSource = null;
            }
        }

        private void ActualizarGrillaTareas()
        {
            try
            {
                if (cboClienteTarea.SelectedIndex != -1 && cboSistemaTarea.SelectedIndex != -1 && cboIncidenteTarea.SelectedIndex != -1)
                {
                    //en este caso es q voy a mostrar los datos q las tareas del incidente
                    IIncidentes ii = LogicaFactory.getInstance().getIIncidentes();
                    DataSistema actualDs = _sistemasTareas.First(ds => ds.Nombre == cboSistemaTarea.SelectedItem.ToString());
                    string datoIncidente = cboIncidenteTarea.SelectedItem.ToString();
                    char[] delimitador = { '=', ';' };
                    string[] palabras = datoIncidente.Split(delimitador);
                    int id = int.Parse(palabras[1]);
                    //obtengo la lista de tareas
                    _tareas = ii.GetTareas(actualDs.Codigo, id);

                    DataTable datosTabla = new DataTable("tablaTareas");
                    datosTabla.Columns.Add("Identificador", typeof(string));
                    datosTabla.Columns.Add("Descripcion", typeof(string));
                    string idT;
                    string desc;


                    foreach (DataTarea dt in _tareas)
                    {
                        idT = dt.IdTarea;
                        desc = dt.Descripcion;
                        DataRow dataR = datosTabla.NewRow();
                        dataR[0] = idT;
                        dataR[1] = desc;
                        datosTabla.Rows.Add(dataR);

                    }

                    grillaTareas.DataSource = datosTabla;
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        
        }

        private void btnActualizarTarea_Click(object sender, EventArgs e)
        {
            try
            {
                if (cboClienteTarea.SelectedIndex != -1 && cboSistemaTarea.SelectedIndex != -1 && cboIncidenteTarea.SelectedIndex != -1)
                {
                    //en este caso es q voy a mostrar los datos q las tareas del incidente
                    IIncidentes ii = LogicaFactory.getInstance().getIIncidentes();
                    DataSistema actualDs = _sistemasTareas.First(ds => ds.Nombre == cboSistemaTarea.SelectedItem.ToString());


                    string datoIncidente = cboIncidenteTarea.SelectedItem.ToString();
                    char[] delimitador = { '=', ';' };
                    string[] palabras = datoIncidente.Split(delimitador);
                    int id = int.Parse(palabras[1]);
                    //obtengo la lista de tareas
                    _tareas = ii.GetTareas(actualDs.Codigo, id);

                    DataTable datosTabla = new DataTable("tablaTareas");
                    datosTabla.Columns.Add("Identificador", typeof(string));
                    datosTabla.Columns.Add("Descripcion", typeof(string));
                    string idT;
                    string desc;


                    foreach (DataTarea dt in _tareas)
                    {
                        idT = dt.IdTarea;
                        desc = dt.Descripcion;
                        DataRow dataR = datosTabla.NewRow();
                        dataR[0] = idT;
                        dataR[1] = desc;
                        datosTabla.Rows.Add(dataR);

                    }

                    grillaTareas.DataSource = datosTabla;

                }
                else
                {

                    MsgNotificacion n = new MsgNotificacion("Faltan datos", "Ingrese cliente, sistema, incidente", "Debe seleccionar el cliente, el sistema y el incidente");
                    n.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }

        private void btnAsignarResp_Click(object sender, EventArgs e)
        {
            try
            {
                int i = obtenerIndiceTareaSeleccionado();
                if (i >= 0)
                {

                    DataTarea dTarea = _tareas.ElementAt(i);
                    DataSistema actualDs = _sistemasTareas.First(ds => ds.Nombre == cboSistemaTarea.SelectedItem.ToString());
                    string datoIncidente = cboIncidenteTarea.SelectedItem.ToString();
                    char[] delimitador = { '=', ';' };
                    string[] palabras = datoIncidente.Split(delimitador);
                    int id = int.Parse(palabras[1]);

                    AsignarResponsableATarea art = new AsignarResponsableATarea(actualDs.Codigo, id, dTarea);
                    art.ShowDialog();
                }
                else
                {
                    MsgError er = new MsgError("Error", "Debe seleccionar un dato", "Para poder asignar responsable a tarea debe seleccionar un cliente, sistema, incidente y tarea");
                    er.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError er = new MsgError("Error", "", ex.Message);
                er.ShowDialog();
            }
        }

        private void VolverAEstadoInicialTareas()
        {
            cboSistemaTarea.SelectedIndex = -1;
            cboSistemaTarea.Items.Clear();
            cboSistemaTarea.Enabled = false;
            cboIncidenteTarea.SelectedIndex = -1;
            cboIncidenteTarea.Items.Clear();
            cboIncidenteTarea.Enabled = false;
            grillaTareas.DataSource = null;
            _incidentesTareas = null;
            _sistemasTareas = null;
            _tareas = null;

        }

        private void btnElimTarea_Click(object sender, EventArgs e)
        {
            try
            {
                if (grillaTareas.DataSource != null)
                {

                    int i = obtenerIndiceTareaSeleccionado();
                    if (i >= 0)
                    {
                        DataTarea dTarea = _tareas.ElementAt(i);
                        DataSistema actualDs = _sistemasTareas.First(ds => ds.Nombre == cboSistemaTarea.SelectedItem.ToString());
                        IIncidentes ii = LogicaFactory.getInstance().getIIncidentes();
                        ii.EliminarTarea(actualDs.Codigo, int.Parse(dTarea.IdTarea));
                        MsgNotificacion notif = new MsgNotificacion("Eliminacion exitosa", "", "Se ha eliminado la tarea seleccionada con éxito");
                        notif.ShowDialog();
                        ActualizarGrillaTareas();

                    }
                    else
                    {
                        MsgError er = new MsgError("Error", "No se seleccionó ninguna tarea", "Para poder eliminar una tarea debe seleccionar previamente la tarea que desea eliminar");
                        er.ShowDialog();
                    }
                }
                else
                {
                    MsgError err = new MsgError("Error", "No se seleccionó ninguna tarea", "Para poder eliminar una tarea debe seleccionar previamente la tarea que desea eliminar");
                    err.ShowDialog();
                }

            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
         
            
        }

        #endregion



        

  
 
       
       
        
       
       
        private void dataGridViewIncidentes_CellContentClick(object sender, DataGridViewCellEventArgs e)
        {

        }

      

        private void groupBox5_Enter(object sender, EventArgs e)
        {

        }

        #region Clientes

        private void ActualizarTablaClientes()
        {
            try
            {

                DataTable datosCliente = new DataTable("tablaClientes");
                datosCliente.Columns.Add("Nombre", typeof(string));
                if (txtNomCli.Text == "")
                {
                    foreach (DataCliente dc in _clientes)
                    {
                        DataRow dataR = datosCliente.NewRow();
                        dataR[0] = dc.Nombre;
                        datosCliente.Rows.Add(dataR);

                    }
                }
                else
                {
                    foreach (DataCliente dc in _clientes)
                    {
                        if (dc.Nombre.Contains(txtNomCli.Text))
                        {
                            DataRow dataR = datosCliente.NewRow();
                            dataR[0] = dc.Nombre;
                            datosCliente.Rows.Add(dataR);

                        }
                    }

                }
                grillaClientes.DataSource = datosCliente;
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();

            }

        
        }
        private void btnActualizarClientes_Click(object sender, EventArgs e)
        {

            ActualizarTablaClientes();
        }
        private int obtenerIndiceClienteSeleccionado()
        {
            DataGridViewSelectedRowCollection col = grillaClientes.SelectedRows;
            bool salir = false;
            int i = 0;
            while (!salir && i < grillaClientes.RowCount)
            {
                DataGridViewRow fila = grillaClientes.Rows[i];
                if (col.Contains(fila))
                {
                    salir = true;

                }
                else
                {
                    i++;
                }
            }
            if (salir)
                return i;
            else
                return -1;
        }
        private void btnAgregarCli_Click(object sender, EventArgs e)
        {
            AltaCliente ac = new AltaCliente();
            ac.ShowDialog();
            
            VolverAEstadoInicialGeneral();
            
        }

        private void btnEliminar_Click(object sender, EventArgs e)
        {
            try
            {
                if (grillaClientes.DataSource != null)
                {
                    int posCli = obtenerIndiceClienteSeleccionado();
                    if (posCli >= 0)
                    {
                        //existe un cliente seleccionado
                        //obtengo el cliente seleccionado
                        DataCliente dataCli = _clientes.ElementAt(posCli);
                        IClientes ic = LogicaFactory.getInstance().getIClientes();
                        ic.BajaCliente(dataCli.Codigo);
                        MsgNotificacion notif = new MsgNotificacion("Baja Cliente", "Baja Exitosa", "Se ha dado de baja el cliente con nombre " + dataCli.Nombre);
                        notif.ShowDialog();
                        VolverAEstadoInicialGeneral();


                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningun cliente", "Debe seleccionar el cliente a eliminar");
                        err.ShowDialog();
                    }

                }
                else
                {
                    MsgError err = new MsgError("Error", "No se seleccionó ningun cliente", "Debe seleccionar el cliente a eliminar");
                    err.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }

        }

        private void btnModificarCliente_Click(object sender, EventArgs e)
        {
            try
            {
                if (grillaClientes.DataSource != null)
                {
                    int posCli = obtenerIndiceClienteSeleccionado();
                    if (posCli >= 0)
                    {
                        //existe un cliente seleccionado
                        //obtengo el cliente seleccionado
                        DataCliente dataCli = _clientes.ElementAt(posCli);
                        ModificarCliente modif = new ModificarCliente(dataCli);
                        modif.ShowDialog();
                        VolverAEstadoInicialGeneral();
                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningun cliente", "Debe seleccionar el cliente a modificar");
                        err.ShowDialog();
                    }

                }
                else
                {
                    MsgError err = new MsgError("Error", "No se seleccionó ningun cliente", "Debe seleccionar el cliente a modificar");
                    err.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
           
        }
        #endregion





        #region SistemasCliente

        private void cboClienteSol_SelectedIndexChanged(object sender, EventArgs e)
        {
         
        }
        private void cboSolucionSol_SelectedIndexChanged(object sender, EventArgs e)
        {
            //vacio la grilla de los sistemas
            grillaSistemas.DataSource = null;
        }

        private void VolverAEstadoInicialSistemas()
        {
            grillaSistemas.DataSource = null;
        
        }

        private int ObtenerIndiceSistemaSeleccionado()
        {
            DataGridViewSelectedRowCollection col = grillaSistemas.SelectedRows;
            bool salir = false;
            int i = 0;
            while (!salir && i < grillaSistemas.RowCount)
            {
                DataGridViewRow fila = grillaSistemas.Rows[i];
                if (col.Contains(fila))
                {
                    salir = true;

                }
                else
                {
                    i++;
                }
            }
            if (salir)
                return i;
            else
                return -1;
        }

        private void ActualizarGrillaSistemas()
        {
            try
            {
                if (cboClienteSol.SelectedIndex != -1)
                {

                    //pido los sistemas
                    LogicaFactory fabrica = LogicaFactory.getInstance();
                    ISistemas sist = fabrica.getISistemas();

                    //obtengo los datos del cliente seleccionado
                    DataCliente actualDc = _clientes.First(dc => dc.Nombre == cboClienteSol.SelectedItem.ToString());

                    //pido los sistemas y los cargo el la grilla de sistemas
                    _sistemasSoluciones = sist.GetSistemas(actualDc.Codigo);
                    DataTable datosTabla = new DataTable("tablaSistemas");
                    datosTabla.Columns.Add("Nombre", typeof(string));
                    datosTabla.Columns.Add("Sitio", typeof(string));
                    foreach (DataSistema ds in _sistemasSoluciones)
                    {
                        DataRow dataR = datosTabla.NewRow();
                        dataR[0] = ds.Nombre;
                        dataR[1] = ds.Sitio;
                        datosTabla.Rows.Add(dataR);
                    }


                    grillaSistemas.DataSource = datosTabla;
                }
                else
                {
                    MsgError err = new MsgError("Error", "Seleccione un cliente", "Para poder ver los sistemas de un cliente debe seleccionar previamente el cliente");
                    err.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        
        }

        private void btnActualizarSol_Click(object sender, EventArgs e)
        {
            ActualizarGrillaSistemas();
                  
        }
        private void btnAgregarSol_Click(object sender, EventArgs e)
        {
            AltaSistema altaSis = new AltaSistema();
            altaSis.ShowDialog();
            VolverAEstadoAntesSistema();
            if(cboClienteSol.SelectedIndex!=-1)
                ActualizarGrillaSistemas();
            
            
        }



        private void btnElimSistema_Click(object sender, EventArgs e)
        {
            try
            {
                if (grillaSistemas.DataSource != null)
                {
                    int posSis = ObtenerIndiceSistemaSeleccionado();
                    if (posSis >= 0)
                    {
                        //existe un sistma seleccionado
                        //obtengo el sistema seleccionado
                        DataSistema dataSis = _sistemasSoluciones.ElementAt(posSis);
                        ISistemas isis= LogicaFactory.getInstance().getISistemas();
                        isis.BajaSistema(dataSis.Codigo);
                        VolverAEstadoAntesSistema();
                        ActualizarGrillaSistemas();
                        MsgNotificacion notif = new MsgNotificacion("Eliminacion exitosa", "", "Se ha eliminado con éxito el sistema");
                        notif.ShowDialog();
                        
                 
                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningun sistema", "Debe seleccionar el sistema a eliminar");
                        err.ShowDialog();
                    }

                }
                else
                {
                    if (cboClienteSol.SelectedIndex == -1)
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningun cliente", "Debe seleccionar un cliente");
                        err.ShowDialog();
                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningún sistema", "Debe seleccionar el sistema a eliminar");
                        err.ShowDialog();
                    }
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }

        private void btnModifSol_Click(object sender, EventArgs e)
        {
            try
            {
                if (grillaSistemas.DataSource != null)
                {
                    int posSis = ObtenerIndiceSistemaSeleccionado();
                    if (posSis >= 0)
                    {
                        //existe un sistma seleccionado
                        //obtengo el sistema seleccionado
                        DataSistema dataSis = _sistemasSoluciones.ElementAt(posSis);
                        ModificarSistema modifSis = new ModificarSistema(dataSis);
                        modifSis.ShowDialog();
                        VolverAEstadoAntesSistema();
                        ActualizarGrillaSistemas();
                      


                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningun sistema", "Debe seleccionar el sistema a modificar");
                        err.ShowDialog();
                    }

                }
                else
                {
                    if (cboClienteSol.SelectedIndex == -1)
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningun cliente", "Debe seleccionar un cliente");
                        err.ShowDialog();
                    }
                    else
                    {
                        MsgError err = new MsgError("Error", "No se seleccionó ningún sistema", "Debe seleccionar el sistema a modificar");
                        err.ShowDialog();
                    }
                }
            }
            catch (Exception ex)
            {
                MsgError err = new MsgError("Error", "", ex.Message);
                err.ShowDialog();
            }
        }

        #endregion


        private void button5_Click(object sender, EventArgs e)
        {

        }

        private void txtNomCli_TextChanged(object sender, EventArgs e)
        {

        }

        private void comboBox6_SelectedIndexChanged(object sender, EventArgs e)
        {

        }

        private void groupBox3_Enter(object sender, EventArgs e)
        {

        }
        #region Hitos
        private void btnAgregarHito_Click(object sender, EventArgs e)
        {
            MsgNotificacion msg = new MsgNotificacion("No implementado", "", "No se ha implementado la acción para agregar hitos");
            msg.ShowDialog();
        }


        private void btnModificarHito_Click(object sender, EventArgs e)
        {
            MsgNotificacion msg = new MsgNotificacion("No implementado", "", "No se ha implementado la acción para modifica un hito");
            msg.ShowDialog();
        }


        private void btnVisualizarHito_Click(object sender, EventArgs e)
        {
            MsgNotificacion msg = new MsgNotificacion("No implementado", "", "No se ha implementado la acción para visualizar un hito");
            msg.ShowDialog();
        }
        #endregion

        private void buttonReporteIncidentes_Click(object sender, EventArgs e)
        {
            ReporteIncidentesCerradosPeriodo ricp = new ReporteIncidentesCerradosPeriodo();
            ricp.ShowDialog();
        }

        private void button3_Click(object sender, EventArgs e)
        {
            ReporteIncidentesAsignadosPeriodo ria = new ReporteIncidentesAsignadosPeriodo();
            ria.ShowDialog();
        }

        private void button4_Click(object sender, EventArgs e)
        {
            ReporteIncidentesCreadosPeriodo rca = new ReporteIncidentesCreadosPeriodo();
            rca.ShowDialog();
        }

        private void button8_Click(object sender, EventArgs e)
        {
            ReporteWPCreadosPeriodo rwpc = new ReporteWPCreadosPeriodo();
            rwpc.ShowDialog();
        }

        private void groupBox4_Enter(object sender, EventArgs e)
        {

        }

        

       
      

    }
}
